package cuatroenraya.jugadores;

import java.util.ArrayList;
import java.util.Collections;
import cuatroenraya.Jugador;

public class JugadorAlumnoG31 extends Jugador {
	
	public static int CANTIDAD_VALORES_HEURISTICAS = 2;
	public static int CANTIDAD_DE_NIVELES_A_RECORRER = 8;
	
	public static int SIN_FICHA = 0;
	public static int FICHA_NUESTRA = 1;
	public static int FICHA_OPONENTE = 2;
	
	public static int HEURISTICA_PESO_DE_GANAR = 70;
	public static float HEURISTICA_PENALIZACION_POR_NIVEL = 3;
	
	public static int HEURISTICA_PESO_POR_FICHA = 10;
	public static int HEURISTICA_PESO_POR_ESPACIO = 5;
	

	@Override
	public int[] jugar(int[][] tablero) { 
		int suma = 0;
		int fila,columna;
		int[] posicionAJugar;
		
		
		//TURNO 1
		for(fila=0; fila<8; fila++) {
			for(columna=0; columna<8; columna++) {
				suma+=tablero[fila][columna];	
			}
		}
		if(suma==0){
			posicionAJugar = new int[2];
			posicionAJugar[0]=3;
			posicionAJugar[1]=3;
			return posicionAJugar;
		}

		
		//TURNOS MAYORES A a 1
		
		//Calculo el tablero de heuristica con el tablero actual
		int[][] tableroHeuristica= calcularHeuristica(tablero);

		System.out.println("Tablero Heuristica\n");
		imprimirMatriz(tableroHeuristica);
		
		//Tomando el Tablero de heuristica, guardo las posiciones que tengan los valores mas altos
		ArrayList<int[]> posicionesAJugar = calcularPosicionAJugar(tableroHeuristica);
		System.out.println("Posiciones a Jugar");
		imprimirVectorDeInt(posicionesAJugar);
		
		//Armo un arbol por cada posicion con valor mas alto, y veo la convenincia de jugar en esa posicion
		int[] convenienciaDeJugarUnaPosicion = new int[posicionesAJugar.size()];
		for(int i=0;i<posicionesAJugar.size();i++){
			convenienciaDeJugarUnaPosicion[i] = armarArbolEnPosicion(tablero,posicionesAJugar.get(i), 1);
		}
		System.out.println("Valores de Conveniencia: ");
		imprimirVector(convenienciaDeJugarUnaPosicion);
		
		//Devuelve la posicion cuyo valor de conveniencia sea mayor
		ArrayList<int[]> posicionesAJugarConValorMaximo = new ArrayList<int[]>();
		int valorMaximoConveniencia = convenienciaDeJugarUnaPosicion[0];
		posicionesAJugarConValorMaximo.add(posicionesAJugar.get(0));
		
		for(int i=1;i<posicionesAJugar.size();i++){
			if(valorMaximoConveniencia <= convenienciaDeJugarUnaPosicion[i]){
				if(valorMaximoConveniencia < convenienciaDeJugarUnaPosicion[i]){
					valorMaximoConveniencia = convenienciaDeJugarUnaPosicion[i];
					posicionesAJugarConValorMaximo = new ArrayList<int[]>();
				}
				posicionesAJugarConValorMaximo.add(posicionesAJugar.get(i));
			}
		}
		
		System.out.println("posicionesAJugarConValorMaximo: "+posicionesAJugarConValorMaximo.size());
		imprimirVectorDeInt(posicionesAJugarConValorMaximo);
		
		if(posicionesAJugarConValorMaximo.size()>1) {
			return posicionesAJugarConValorMaximo.get((int) ((posicionesAJugarConValorMaximo.size())*Math.random()));
		}
		return posicionesAJugarConValorMaximo.get(0);
		 
	}
	private void imprimirVectorDeInt(ArrayList<int[]> vectores) {
		String line=new String();
		for(int vector=0; vector<vectores.size(); vector++) {
			for(int columna=0; columna<2; columna++) {
				line+=vectores.get(vector)[columna]+ ";";
			}
			System.out.println(line);
			line="";
		}
		System.out.println("");
		System.out.println(line);
	}
	
	private void imprimirVector(int[] vector){
		String line=new String();
		for(int fila=0; fila<vector.length; fila++) {
			line+=vector[fila]+ "\r";
		}
		System.out.println(line);
	}
	
	private void imprimirMatriz(int[][] tablero) {
		String line=new String();
		for(int fila=0; fila<8; fila++) {
			for(int columna=0; columna<8; columna++) {
				line+=tablero[fila][columna]+ "  ";
			}
			System.out.println(line);
			line="";
		}
		System.out.println("");
	}
	

	private int[][] calcularTableroConJugada(int tablero[][], int[][] tableroResultanteDeJugarEnUnaPosicion, int[] jugada, int nivel){
		//Ver esto, seria
		for(int fila=0; fila<8; fila++) {
			for(int columna=0; columna<8; columna++) {
				tableroResultanteDeJugarEnUnaPosicion[fila][columna] = tablero[fila][columna];
			}
		}
		tableroResultanteDeJugarEnUnaPosicion[jugada[0]][jugada[1]] += (1+(nivel%2));
		return tableroResultanteDeJugarEnUnaPosicion;
	}
	
	
	


	private int[][] calcularHeuristica(int tablero[][]){
		int tableroHeuristica[][]=new int[8][8];
		int fila,columna;
		for(fila=0; fila<8; fila++) {
			for(columna=0; columna<8; columna++) {
				if(tablero[fila][columna]!=0){
					tableroHeuristica=calcularHeuristicaEnUnPunto(tablero,tableroHeuristica,fila,columna);
				}
			}
		}
		return tableroHeuristica;
	}
	
	
	
	public int armarArbolEnPosicion(int[][] tablero,int[] posicionAJugar, int nivel) {

		//Varible para acumular el valor de Conveniencia de jugar por esta rama
		int convenienciaDeJugarPorEstaRamaEnEstaPosicion = 0;
		
		//Calculo el tablero resultante de jugar en la posicion
		int tableroResultanteDeJugarEnUnaPosicion[][] = new int[8][8];
		calcularTableroConJugada(tablero, tableroResultanteDeJugarEnUnaPosicion, posicionAJugar, nivel);
		
		//imprimirMatriz(tableroResultanteDeJugarEnUnaPosicion);
		
		//Calculo tablero de heruristica, con el tablero resultante de jugar en la posicion 
		int[][] tableroHeuristica= calcularHeuristica(tableroResultanteDeJugarEnUnaPosicion);
		

		//imprimirMatriz(tableroHeuristica);
		
		//Calculo las posibles posiciones a jugar segun la heuristica calculado con el tablero resultante de jugar en la posicion 
		ArrayList<int[]> posicionesAJugar = calcularPosicionAJugar(tableroHeuristica);
		
		//Recorro las posiciones posible a jugar, calculando la conveniencia.
		//Si uno gana se corta el arbol ahi, devolviendose un conveniencia grande si ganamos nosotros, y un valor muy bajo si el oponente gana
		for(int i=0;i<posicionesAJugar.size();i++){
			
			//Controla si en ese movimiento gano alguno, si alguno gano corta sino arma el arbol
			if(!controlarJugadaGanadora(tableroResultanteDeJugarEnUnaPosicion, posicionesAJugar.get(i))) {
				//System.out.println(((nivel%2)*2-1)*HEURISTICA_PESO_DE_GANAR);
				return (int) (((nivel%2)*2-1)* //Mio o suyo
				HEURISTICA_PESO_DE_GANAR*
				((CANTIDAD_DE_NIVELES_A_RECORRER-nivel+1)*HEURISTICA_PENALIZACION_POR_NIVEL));
			} else {
				//Calcula la conveniencia en este estado del tablero
				convenienciaDeJugarPorEstaRamaEnEstaPosicion = calcularConvenienciaDeLaPosicion(tableroResultanteDeJugarEnUnaPosicion,posicionesAJugar.get(i), nivel);
				
				//Controlo si llegeue al nivel de corte, si llegue devuelvo el valor de conveniencia, sino sigo armando el arbol
				if(nivel==CANTIDAD_DE_NIVELES_A_RECORRER) {
					return convenienciaDeJugarPorEstaRamaEnEstaPosicion;
				} else {
					convenienciaDeJugarPorEstaRamaEnEstaPosicion += armarArbolEnPosicion(tableroResultanteDeJugarEnUnaPosicion, posicionesAJugar.get(i), nivel+1);
				}
			}
		}
		
		return convenienciaDeJugarPorEstaRamaEnEstaPosicion;
	}
	
	
	private int calcularConvenienciaDeLaPosicion(int[][] tablero,int[] posicionAJugar, int nivel) {
		int cantidadFichas = 0;
		int cantidadEspacios = 0;
		
		return 0;
		/*
		return (1-(nivel%2)*2)* // positivo si es mi turno, negativo si es el turno del otro
		(HEURISTICA_PESO_POR_FICHA*cantidadFichas +HEURISTICA_PESO_POR_ESPACIO*cantidadEspacios)* //pesos por fichas y por espacios
		(nivel*HEURISTICA_PENALIZACION_POR_NIVEL); //penalizacion por nivel
		*/
	}
	
	
	
	private int[][] calcularHeuristicaEnUnPunto(int tablero[][], int tableroHeuristica[][],int fila, int columna){
		//por cada ficha en el tablero de juego
		
		int valorDeFichaQueLlego=tablero[fila][columna]; // 1 si es nuestra, 2 sino
		int valorFichaDelOtro = 1;
		if(valorDeFichaQueLlego==1){valorFichaDelOtro = 2;}
		
		
		tableroHeuristica[fila][columna]-=100; // posicion donde esta la ficha
		ArrayList<Integer[]> posiciones = new ArrayList<Integer[]>(); 
		// posiciones : { fila ; columna; indice de linea; indice de proximidad  }
		// guarda los posiciones en que se debe agregar peso pq son lugares donde es posible hacer una linea
		//indice de proximidad =3 al lado de la ficha, pues 2, pues 1
		//indice de linea=2 o 4
		
		
		posiciones=calcularHeuristicaEnUnPuntoHorizontal(tablero,posiciones,fila,columna,valorDeFichaQueLlego,valorFichaDelOtro);
		posiciones=calcularHeuristicaEnUnPuntoVertical(tablero,posiciones,fila,columna,valorDeFichaQueLlego,valorFichaDelOtro);
		posiciones=calcularHeuristicaEnUnPuntoDiagonalIzquierda(tablero,posiciones,fila,columna,valorDeFichaQueLlego,valorFichaDelOtro);
		posiciones=calcularHeuristicaEnUnPuntoDiagonalDerecha(tablero,posiciones,fila,columna,valorDeFichaQueLlego,valorFichaDelOtro);
		//
		
		/////////////// calculer avec positions et ajouter (ou multiplier) au tableau heuristique ///////////
		
		// poniendo los pesos donde se pueden hacer lineas	
		for(Integer[] posicionASetear: posiciones){ // para cada elemento de la lista posiciones
			
			tableroHeuristica[posicionASetear[0]][posicionASetear[1]]+=(1+posicionASetear[3]+posicionASetear[2]*valorFichaDelOtro*5);// bien agresivo
			//tableroHeuristica[posicionASetear[0]][posicionASetear[1]]+=(posicionASetear[3]+posicionASetear[2]);
		}

	
		return tableroHeuristica;
	}
	

	private ArrayList<Integer[]> calcularHeuristicaEnUnPuntoHorizontal(int tablero[][], ArrayList<Integer[]> posiciones,
			int fila, int columna, int valorDeFichaQueLlego, int valorFichaDelOtro){
		
		int columnaAuxiliar; // columna q estamos evaluendo
		int cantidadLugares=1; // lugares vacios o conteniendo fichas del mismo jugador de la q examinamos
		int indiceProximidad;
		int indiceLinea;//////

		ArrayList<Integer[]> posicionesBuffer = new ArrayList<Integer[]>();
		
		columnaAuxiliar=columna-1;
		indiceProximidad=3;
		indiceLinea=0;
		//recorrer horizontal izquierda
		while (columnaAuxiliar>=0 && tablero[fila][columnaAuxiliar]!=valorFichaDelOtro && indiceProximidad>0){
			cantidadLugares++;
			indiceProximidad--;
			indiceLinea+=(tablero[fila][columnaAuxiliar]*valorFichaDelOtro);
			posicionesBuffer.add(new Integer[]{fila,columnaAuxiliar,indiceLinea,indiceProximidad});
			columnaAuxiliar-=1;
		}
		
		// new Integer[]{filaAuxiliar,columnaAuxiliar}

		columnaAuxiliar=columna+1;
		indiceProximidad=3;
		indiceLinea=0;
		//recorrer horizontal derecha
		while (columnaAuxiliar<=7 && tablero[fila][columnaAuxiliar]!=valorFichaDelOtro && indiceProximidad>0){
			cantidadLugares++;
			indiceProximidad--;
			indiceLinea+=(tablero[fila][columnaAuxiliar]*valorFichaDelOtro);
			posicionesBuffer.add(new Integer[]{fila,columnaAuxiliar,indiceLinea,indiceProximidad});
			columnaAuxiliar+=1;
		}
		
		if(cantidadLugares>=4){
			posiciones.addAll(posicionesBuffer);
		}
		
		return posiciones;
	}
	
	
	private ArrayList<Integer[]> calcularHeuristicaEnUnPuntoVertical(int tablero[][] ,ArrayList<Integer[]> posiciones,
			int fila, int columna, int valorDeFichaQueLlego, int valorFichaDelOtro){
		
		int filaAuxiliar; // fila q estamos evaluendo
		int cantidadLugares=1; // lugares vacios o conteniendo fichas amigas
		int indiceProximidad;
		int indiceLinea;
		
		
		ArrayList<Integer[]> posicionesBuffer = new ArrayList<Integer[]>();
		
		filaAuxiliar=fila-1;
		indiceProximidad=3;
		indiceLinea=0;
		//recorrer vertical arriba
		while (filaAuxiliar>=0 && tablero[filaAuxiliar][columna]!=valorFichaDelOtro && indiceProximidad>0){
			cantidadLugares++;
			indiceProximidad--;
			indiceLinea+=(tablero[filaAuxiliar][columna]*valorFichaDelOtro);
			posicionesBuffer.add(new Integer[]{filaAuxiliar,columna,indiceLinea,indiceProximidad});
			filaAuxiliar-=1;
		}
		
		
		filaAuxiliar=fila+1;
		indiceProximidad=3;
		indiceLinea=0;
		//recorrer vertical abajo
		while (filaAuxiliar<=7 && tablero[filaAuxiliar][columna]!=valorFichaDelOtro && indiceProximidad>0){
			cantidadLugares++;
			indiceProximidad--;
			indiceLinea+=(tablero[filaAuxiliar][columna]*valorFichaDelOtro);
			posicionesBuffer.add(new Integer[]{filaAuxiliar,columna,indiceLinea,indiceProximidad});
			filaAuxiliar+=1;
		}
		
		if(cantidadLugares>=4){
			posiciones.addAll(posicionesBuffer);
		}
		
		return posiciones;
	}
	

	/**
	 * Diagonal Izquierda es la que empieza en la posicion 0,0
	 * @param tablero
	 * @param posiciones
	 * @param fila
	 * @param columna
	 * @return posiciones
	 */
	private ArrayList<Integer[]> calcularHeuristicaEnUnPuntoDiagonalIzquierda(int tablero[][] ,ArrayList<Integer[]> posiciones, int fila, int columna, int valorDeFichaQueLlego, int valorFichaDelOtro){
		
		int filaAuxiliar,columnaAuxiliar;// fila y columna q estamos evaluendo
		int cantidadLugares=1; // lugares vacios o conteniendo fichas amigas
		int indiceProximidad;
		int indiceLinea;
		ArrayList<Integer[]> posicionesBuffer = new ArrayList<Integer[]>();

		filaAuxiliar=fila-1;
		columnaAuxiliar=columna-1;
		indiceProximidad=3;
		indiceLinea=0;
		//recorrer diagonal izquierda para arriba
		while (filaAuxiliar>=0 && columnaAuxiliar>=0 && tablero[filaAuxiliar][columnaAuxiliar]!=valorFichaDelOtro && indiceProximidad>0){
			cantidadLugares++;
			indiceProximidad--;
			indiceLinea+=(tablero[filaAuxiliar][columnaAuxiliar]*valorFichaDelOtro);
			posicionesBuffer.add(new Integer[]{filaAuxiliar,columnaAuxiliar,indiceLinea,indiceProximidad});
			filaAuxiliar-=1;
			columnaAuxiliar-=1;
		}
		

		filaAuxiliar=fila+1;
		columnaAuxiliar=columna+1;
		indiceProximidad=3;
		indiceLinea=0;
		//recorrer diagonal izquierda para abajo
		while (filaAuxiliar<=7 && columnaAuxiliar<=7 && tablero[filaAuxiliar][columnaAuxiliar]!=valorFichaDelOtro && indiceProximidad>0){
			cantidadLugares++;
			indiceProximidad--;
			indiceLinea+=(tablero[filaAuxiliar][columnaAuxiliar]*valorFichaDelOtro);
			posicionesBuffer.add(new Integer[]{filaAuxiliar,columnaAuxiliar,indiceLinea,indiceProximidad});
			filaAuxiliar+=1;
			columnaAuxiliar+=1;
		}

		if(cantidadLugares>=4){
			posiciones.addAll(posicionesBuffer);
		}
		
		return posiciones;
	}
	


	/**
	 * Diagonal Izquierda es la que empieza en la posicion 0,0
	 * @param tablero
	 * @param tableroHeuristica
	 * @param fila
	 * @param columna
	 * @return
	 */
private ArrayList<Integer[]> calcularHeuristicaEnUnPuntoDiagonalDerecha(int tablero[][] ,ArrayList<Integer[]> posiciones,int fila, int columna, int valorDeFichaQueLlego, int valorFichaDelOtro){
		
		int filaAuxiliar,columnaAuxiliar;// fila y columna q estamos evaluendo
		int cantidadLugares=1; // lugares vacios o conteniendo fichas amigas
		int indiceProximidad;
		int indiceLinea;
		ArrayList<Integer[]> posicionesBuffer = new ArrayList<Integer[]>();

		filaAuxiliar=fila-1;
		columnaAuxiliar=columna+1;
		indiceProximidad=3;
		indiceLinea=0;
		//recorrer diagonal derecha para arriba
		while (filaAuxiliar>=0 && columnaAuxiliar<=7 && tablero[filaAuxiliar][columnaAuxiliar]!=valorFichaDelOtro && indiceProximidad>0){
			cantidadLugares++;
			indiceProximidad--;
			indiceLinea+=(tablero[filaAuxiliar][columnaAuxiliar]*valorFichaDelOtro);
			posicionesBuffer.add(new Integer[]{filaAuxiliar,columnaAuxiliar,indiceLinea,indiceProximidad});
			filaAuxiliar-=1;
			columnaAuxiliar+=1;
		}
		

		filaAuxiliar=fila+1;
		columnaAuxiliar=columna-1;
		indiceProximidad=3;
		indiceLinea=0;
		//recorrer diagonal derecha para abajo
		while (columnaAuxiliar>=0 && filaAuxiliar<=7 && tablero[filaAuxiliar][columnaAuxiliar]!=valorFichaDelOtro && indiceProximidad>0){
			cantidadLugares++;
			indiceProximidad--;
			indiceLinea+=(tablero[filaAuxiliar][columnaAuxiliar]*valorFichaDelOtro);
			posicionesBuffer.add(new Integer[]{filaAuxiliar,columnaAuxiliar,indiceLinea,indiceProximidad});
			filaAuxiliar+=1;
			columnaAuxiliar-=1;
		}
		
		
		if(cantidadLugares>=4){
			posiciones.addAll(posicionesBuffer);
		}
		
		return posiciones;
	}
	


	// El tablero, el jugador que tiene que mover, la coordenada que quiere mover.
	private boolean controlarJugadaGanadora(int[][] tablero, int[] jugada)
	{
	    int vert = 0;
	    int horiz = 0;
	    int diag45 = 0;
	    int diag135 = 0;
	    int ficha = tablero[jugada[0]][jugada[1]];
	//    JOptionPane.showMessageDialog(null,jugada[0] + " " + jugada[1] + " Jugador " + ficha);
	    for(int i = 0; i<7;  i++) // for(i = jugada[1]-3; i<=jugada[1]+3;  i++)
	    {   // Los if controlan que los subindices no se salgan de rango, el
	        // resto se hace con los contadores de los "?"
	
	        if(jugada[0]+i-3 < 8 && jugada[0]+i-3 >= 0)
	        {
	            vert = (tablero[jugada[0]+i-3][jugada[1]] == ficha) ? (vert + 1) : (0);
	        }
	        else
	        {
	            vert = 0;
	        }
	        if(jugada[1]+i-3 < 8 && jugada[1]+i-3 >=0)
	        {
	            horiz = (tablero[jugada[0]][jugada[1]+i-3] == ficha) ? (horiz + 1) : (0);
	        }
	        else
	        {
	            horiz = 0;
	        }
	        if(jugada[0]+i-3 < 8 && jugada[0]+i-3 >= 0 && jugada[1]+i-3 < 8 && jugada[1]+i-3 >=0)
	        {
	            diag45 = (tablero[jugada[0]+i-3][jugada[1]+i-3] == ficha) ? (diag45 + 1) : (0);
	        }
	        else
	        {
	            diag45 = 0;
	        }
	        if(jugada[0]-i+3 < 8 && jugada[0]-i+3 >= 0 && jugada[1]+i-3 < 8 && jugada[1]+i-3 >=0)
	        {
	            diag135 = (tablero[jugada[0]-i+3][jugada[1]+i-3] == ficha) ? (diag135 + 1) : (0);
	        }
	        else
	        {
	            diag135 = 0;
	        }
	        if(vert==4 || horiz==4 || diag45==4 || diag135==4) // Controla si algún contador llegó a 4 y termina
	        {
	            return true;
	        }
	    }
	    return false;
	}

	private ArrayList<int[]> calcularPosicionAJugar(int tableroHeuristica[][]) {
		
		int fila,columna;
		int[] posicion = null;
		ArrayList<int[]> posicionAJugar = new ArrayList<int[]>();
		ArrayList<Integer> valoresDelTablero = new ArrayList<Integer>();
		
		//Carga todos los valores que tiene el tablero
		for(fila=0; fila<8; fila++) {
			for(columna=0; columna<8; columna++) {
				if(!valoresDelTablero.contains(tableroHeuristica[fila][columna])){
					valoresDelTablero.add(tableroHeuristica[fila][columna]);
				}
			}
		}
		
		//Ordena los valores
	    Collections.sort(valoresDelTablero);
	    
	    //Toma la los valores maximos a agregar en el armado del tablero
	    ArrayList<Integer> valoresATomarDelTablero = new ArrayList<Integer>();
	    for (int i=0; i<CANTIDAD_VALORES_HEURISTICAS; i++) {
	    	if(valoresDelTablero.get(valoresDelTablero.size()-1-i)>0){
			    valoresATomarDelTablero.add(valoresDelTablero.get(valoresDelTablero.size()-1-i));	    		
	    	}
	    }
		
	    //Carga las posiciones 		
		for(fila=0; fila<8; fila++) {
			for(columna=0; columna<8; columna++) {
				if(valoresATomarDelTablero.contains(tableroHeuristica[fila][columna])){
					posicion = new int[2];
					posicion[0]=fila;
					posicion[1]=columna;
					posicionAJugar.add(posicion);
				}
			}
		}
				
		return posicionAJugar;
	}	
		
	/*
	public ArrayList<int[]> jugarRec(int[][] tablero, int[] posicion, int nivel, int QuienJuega) {

		 int G=0;
		 tablero[posicion]=QuienJuega;
		  
		 if(QuienJuega==1 && gano==1){ // ver como hace el profe para saber cuando alguien gana
		  return {1,posicion} // jugar en este posicion hace q ganamos
		 }
		 if(QuienJuega==2 && gano==1){
		  return {-1,posicion} // jugar en este posicion hace ganar el otro: no es bueno
		 }
		 if(nivel>5){
		  return {0,posicion}
		 }

		 For (int[] pos= cada posicion libre/jugable del tablero) {
		  Res = jugarRec(tablero,pos,nivel+1,3-QuienJuega);
		  G+= Res[0];
		 }
		 
		 Return {G,posicion};
	}
	*/
	

	
	
	/*
	 ArrayList<int[]> valorPos = new  ArrayList<int[]>();
	 // cada elem es {G,fila,columna}

	 For (int[] pos= cada posicion libre/jugable del tablero) {
	  valorPos.add(jugarRec(tablero,pos,1,1);
	 }

	 int[]PosAJugar=elemento_de_valorPos_con_el_G m�s_alto;
	 return (new int{PosAJugar[1],PosAJugar[2]});
	 */
	


	/*

	private boolean controlarJugadaGanadora(int[][] tablero) {
		int cantidadEnLinea = 0;
		int fila, columna, valorDeUltimaFicha;
		
		//Controla horizontal
		cantidadEnLinea=0;
		for(fila=0;fila<8;fila++){
			valorDeUltimaFicha= tablero[fila][0];
			for(columna=1;columna<8;columna++){
				if(valorDeUltimaFicha=tablero[fila][columna]) {
					if(tablero[fila][columna]!=0) {
						cantidadEnLinea++;
						if(cantidadEnLinea==4){
							return true;
						}
					} else {
						cantidadEnLinea=0;
					}
					valorDeUltimaFicha=tablero[fila][columna];
				} else {
					cantidadEnLinea=0;
				}
			}
			cantidadEnLinea=0;
		}
		

		//Controla vertical
		cantidadEnLinea=0;
		for(columna=1;columna<8;columna++){
			valorDeUltimaFicha= tablero[0][columna];
			for(fila=0;fila<8;fila++){
				if(valorDeUltimaFicha==tablero[fila][columna]){
					if(tablero[fila][columna]!=0) {
						cantidadEnLinea++;
						if(cantidadEnLinea==4){
							return true;
						}
					} else {
						cantidadEnLinea=0;
					}
					valorDeUltimaFicha=tablero[fila][columna];
				} else {
					cantidadEnLinea=0;
				}
			}
			cantidadEnLinea=0;
		}
		
		int filaAuxiliar, columnaAuxiliar;
		

		//Controla diagonal 45
		cantidadEnLinea=0;
		filaAuxiliar=4;
		columnaAuxiliar=0;
		boolean primeraPasada=true;
		do {
			if(primeraPasada){
				primeraPasada=false;
			} else {
				if(filaAuxiliar==0) {
					columnaAuxiliar++;
				} else {
					filaAuxiliar--;
				}
			}
			
			for(columna=columnaAuxiliar;columna<8;columna++){
				for(fila=filaAuxiliar;fila<8;fila++){
					if(valorDeUltimaFicha==tablero[fila][columna]) {
						if(tablero[fila][columna]!=0) {
							cantidadEnLinea++;
							if(cantidadEnLinea==4){
								return true;
							}
						} else {
							cantidadEnLinea=0;
						}
						valorDeUltimaFicha=tablero[fila][columna];
					} else {
						cantidadEnLinea=0;
					}
				}
				cantidadEnLinea=0;
				}
			}
			
			
		} while (filaAuxiliar==0 && columnaAuxiliar==4);
		
		
		for(columna=columnaAuxiliar;columna<8;columna++){
			if(filaAuxiliar==0) {
				columna++;
			} else {
				fila--;
			}
			valorDeUltimaFicha= tablero[0][columna];
			for(fila=filaAuxiliar;fila<8;fila++){
				if(valorDeUltimaFicha==tablero[fila][columna]){
					if(tablero[fila][columna]!=0) {
						cantidadEnLinea++;
						if(cantidadEnLinea==4){
							return true;
						}
					} else {
						cantidadEnLinea=0;
					}
					valorDeUltimaFicha=tablero[fila][columna];
				} else {
					cantidadEnLinea=0;
				}
			}
			cantidadEnLinea=0;
		}
		         

		//Controla diagonal 135
		cantidadEnLinea=0;
		for(columna=1;columna<8;columna++){
			valorDeUltimaFicha= tablero[0][columna];
			for(fila=0;fila<8;fila++){
				if(valorDeUltimaFicha=tablero[fila][columna]){
					if(tablero[fila][columna]!=0) {
						cantidadEnLinea++;
						if(cantidadEnLinea==4){
							return true;
						}
					} else {
						cantidadEnLinea=0;
					}
					valorDeUltimaFicha=tablero[fila][columna];
				} else {
					cantidadEnLinea=0;
				}
			}
			cantidadEnLinea=0;
		}
		
		int filaAuxiliar,columnaAuxiliar,
		
		
		filaAuxiliar=fila-1;
		columnaAuxiliar=columna-1;
		indiceProximidad=3;
		indiceLinea=0;
		//recorrer diagonal izquierda para arriba
		while (filaAuxiliar>=0 && columnaAuxiliar>=0 && tablero[filaAuxiliar][columnaAuxiliar]!=valorFichaDelOtro && indiceProximidad>0){
			cantidadLugares++;
			indiceProximidad--;
			indiceLinea+=(tablero[filaAuxiliar][columnaAuxiliar]*valorFichaDelOtro);
			posicionesBuffer.add(new Integer[]{filaAuxiliar,columnaAuxiliar,indiceLinea,indiceProximidad});
			filaAuxiliar-=1;
			columnaAuxiliar-=1;
		}
		

		filaAuxiliar=fila+1;
		columnaAuxiliar=columna+1;
		indiceProximidad=3;
		indiceLinea=0;
		//recorrer diagonal izquierda para abajo
		while (filaAuxiliar<=7 && columnaAuxiliar<=7 && tablero[filaAuxiliar][columnaAuxiliar]!=valorFichaDelOtro && indiceProximidad>0){
			cantidadLugares++;
			indiceProximidad--;
			indiceLinea+=(tablero[filaAuxiliar][columnaAuxiliar]*valorFichaDelOtro);
			posicionesBuffer.add(new Integer[]{filaAuxiliar,columnaAuxiliar,indiceLinea,indiceProximidad});
			filaAuxiliar+=1;
			columnaAuxiliar+=1;
		}

		if(cantidadLugares>=4){
			posiciones.addAll(posicionesBuffer);
		}
		
	}

	*/

}
